#include "include.h"
#include "wireless.h"


void btrf_power_balance_cb(u32 sta);
void btrf_power_balance_init(void);


#if RF_EXT_CTL_EN || RF_PWR_BALANCE_EN
const uint8_t cfg_bb_rf_ctl = BIT(0);   //bit0=RF_EXT_CTL_EN

AT(.com_text.isr.txrx)
void bb_rf_ext_ctl_cb(u32 rf_sta)
{
#if RF_EXT_CTL_EN
    if(rf_sta & BIT(8)) {          //tx
        RF_CTL_IDLE();
        RF_CTL_TX();
    } else if(rf_sta & BIT(10)) {  //rx
        RF_CTL_IDLE();
        RF_CTL_RX();
    } else {                    //idle
        RF_CTL_IDLE();
    }
#endif

#if RF_PWR_BALANCE_EN
    btrf_power_balance_cb(rf_sta);
#endif
}
#endif

#if RF_PWR_BALANCE_EN

#define CONST_CAT(x, y)                    x ## y
#define SET_MACRO(x, y)                    CONST_CAT(x, y)
#define POWER_BALANCE_GPIO_INIT(x, y)     (SET_MACRO(GPIO, SET_MACRO(x, DE)) |= BIT(y), SET_MACRO(GPIO, SET_MACRO(x, FEN)) &= ~BIT(y), SET_MACRO(GPIO, SET_MACRO(x, DIR)) |= BIT(y))

#define POWER_BALANCE_GPIO_UPFDOWN_ON(x, y)     (SET_MACRO(GPIO, SET_MACRO(x, PU300)) |= BIT(y), SET_MACRO(GPIO, SET_MACRO(x, PD300)) |=BIT(y))
#define POWER_BALANCE_GPIO_UPFDOWN_OFF(x, y)     (SET_MACRO(GPIO, SET_MACRO(x, PU300))&= ~  BIT(y), SET_MACRO(GPIO, SET_MACRO(x, PD300)) &= ~ BIT(y))

//AT(.com_text)
//char ttetbf[] = "test2\r\n";
//static uint8_t test_p[] = "@";
volatile u8 btrf_power_level = 0;

void btrf_power_balance_init(void)
{
    POWER_BALANCE_GPIO_INIT(A, 3);
    POWER_BALANCE_GPIO_INIT(A, 4);
    POWER_BALANCE_GPIO_INIT(A, 5);
    POWER_BALANCE_GPIO_INIT(A, 6);

//    POWER_BALANCE_GPIO_INIT(B, 3);
    POWER_BALANCE_GPIO_INIT(B, 4);
    POWER_BALANCE_GPIO_INIT(E, 5);
    POWER_BALANCE_GPIO_INIT(E, 6);
    void timer2_init_for_btrf_power_balance(void);
    timer2_init_for_btrf_power_balance();
}

AT(.com_text.btrf_pwrbalance)
void btrf_power_balance_level_set(u8 level)   //unit 3.3V/600 = 5.5mA
{
    POWER_BALANCE_GPIO_UPFDOWN_OFF(A, 3);
    POWER_BALANCE_GPIO_UPFDOWN_OFF(A, 4);
    POWER_BALANCE_GPIO_UPFDOWN_OFF(A, 5);
    POWER_BALANCE_GPIO_UPFDOWN_OFF(A, 6);
    POWER_BALANCE_GPIO_UPFDOWN_OFF(E, 5);
    POWER_BALANCE_GPIO_UPFDOWN_OFF(E, 6);
    POWER_BALANCE_GPIO_UPFDOWN_OFF(B, 4);
//    POWER_BALANCE_GPIO_UPFDOWN_OFF(B, 3);
    if (0 == level) {
        return;
    }
    if(level >= 1){
        POWER_BALANCE_GPIO_UPFDOWN_ON(A, 3);
    }
    if(level >= 2) {
        POWER_BALANCE_GPIO_UPFDOWN_ON(A, 4);
    }
    if(level >= 3) {
        POWER_BALANCE_GPIO_UPFDOWN_ON(A, 5);
    }
    if(level >= 4) {
        POWER_BALANCE_GPIO_UPFDOWN_ON(A, 6);
    }
    if(level >= 5) {
        POWER_BALANCE_GPIO_UPFDOWN_ON(E, 5);
    }
    if(level >= 6) {
        POWER_BALANCE_GPIO_UPFDOWN_ON(E, 6);
    }
    if(level >= 7) {
        POWER_BALANCE_GPIO_UPFDOWN_ON(B, 4);
    }
    if(level >= 8) {
//        POWER_BALANCE_GPIO_UPFDOWN_ON(B, 3);
    }
}

uint32_t tmr_cnt = 0;
AT(.com_text.btrf_pwrbalance)
void timer2_isr_for_btrf_power_balance(void)
{
    if (TMR2CON & BIT(9)) {
        tmr_cnt++;
        TMR2CPND = BIT(9);              //Clear Pending
        TMR2CON &=  ~BIT(7);
//        printf(test_p);
        btrf_power_balance_level_set(btrf_power_level);
    }
}

typedef void (*isr_t)(void);
isr_t register_isr(int vector, isr_t isr);

void timer2_init_for_btrf_power_balance(void)
{
    printf("%s\n",__func__);
    register_isr(IRQ_TMR2_VECTOR,timer2_isr_for_btrf_power_balance);
    PICPR &= ~BIT(IRQ_TMR2_VECTOR);
    PICEN |= BIT(IRQ_TMR2_VECTOR);
//    CLKCON1 |= BIT(8);                  //timer3 clk en
    TMR2CON =  BIT(7);                  //Timer overflow interrupt enable
    TMR2CNT = 0;
    TMR2PR  = 100000/1;          //1000ms, select xosc26_div 1M clk
    TMR2CON |= BIT(2) | BIT(0);         //Timer works in Counter Mode

}
AT(.com_text.btrf_pwrbalance)
void btrf_power_balance_level_delay_set(u32 delay_us, u8 level)   //unit us
{
    btrf_power_level = level;
    TMR2CNT = 0;
    TMR2PR = delay_us;
    TMR2CPND = BIT(9);
    TMR2CPND = BIT(16);
    TMR2CON |=  BIT(7);
}

AT(.com_text.isr.txrx)
void btrf_power_balance_cb(u32 sta)
{
#if 1
    ///接收端执行功耗配平 参数RX 3 7 59(距离更好 电流声大些 带外adpcm室外大于30m) ->想要距离建议使用这一组   10mA
    if (wireless_role_is_adapter()) {
        if(sta & BIT(8)) {         //tx on
            btrf_power_balance_level_delay_set(68,0);        //TX开始，TX延时一段时间才真正开始耗电，需要延时一段时间后才降低功耗
        }
        else if(sta & BIT(9)){    //tx down
            btrf_power_balance_level_delay_set(10,7);        //TX结束，增加耗电
        }
        else if(sta & BIT(10)) {  //rx on

            btrf_power_balance_level_delay_set(70,5);      //RX开始，RX延时一段时间才真正开始耗电，需要延时一段时间后才降低功耗
        }
        else if(sta & BIT(11)){   //rx down
            btrf_power_balance_level_delay_set(0,7);            //RX结束，增加耗电
        }
        else {                    //idle
            btrf_power_balance_level_delay_set(0,0);             //空闲状态，增加耗电
        }
    }
#else
     ///接收端执行功耗配平 参数RX 3 7 40(效果更好 距离有所牺牲 带外adpcm室外30m) ->电流声问题建议开这一组   43-49 = 6mA
    if (wireless_role_is_adapter()) {
        if(!ble_is_connect()){
            if(sta & BIT(8)) {         //tx on
                btrf_power_balance_level_delay_set(0,0);        //TX开始，TX延时一段时间才真正开始耗电，需要延时一段时间后才降低功耗
            }
            else if(sta & BIT(9)){    //tx down
                btrf_power_balance_level_delay_set(0,7);         //TX结束，增加耗电
            }
            else if(sta & BIT(10)) {  //rx on

                btrf_power_balance_level_delay_set(60,5);      //RX开始，RX延时一段时间才真正开始耗电，需要延时一段时间后才降低功耗
            }
            else if(sta & BIT(11)){   //rx down
                btrf_power_balance_level_delay_set(0,7);            //RX结束，增加耗电
            }
            else {                    //idle
                btrf_power_balance_level_delay_set(0,0);             //空闲状态，增加耗电
            }
        }else{
                        if(sta & BIT(8)) {         //tx on
                btrf_power_balance_level_delay_set(65,0);        //TX开始，TX延时一段时间才真正开始耗电，需要延时一段时间后才降低功耗
            }
            else if(sta & BIT(9)){    //tx down
                btrf_power_balance_level_delay_set(10,5);        //TX结束，增加耗电
            }
            else if(sta & BIT(10)) {  //rx on

                btrf_power_balance_level_delay_set(40,4);      //RX开始，RX延时一段时间才真正开始耗电，需要延时一段时间后才降低功耗
            }
            else if(sta & BIT(11)){   //rx down
                btrf_power_balance_level_delay_set(0,5);            //RX结束，增加耗电
            }
            else {                    //idle
                btrf_power_balance_level_delay_set(0,0);             //空闲状态，增加耗电
            }
        }
    }
#endif // 1
}

#endif // RF_PWR_BALANCE_EN

